/**
 * @typedef {import('unist').Node} Node
 * @typedef {import('unist').Parent} Parent
 *
 * @typedef {string} Type
 * @typedef {Object<string, unknown>} Props
 */
/**
 * Check if a node passes a test
 *
 * @callback TestFunctionAnything
 * @param {Node} node
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {boolean|void}
 */
/**
 * Check if a node passes a certain node test
 *
 * @template {Node} X
 * @callback TestFunctionPredicate
 * @param {Node} node
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {node is X}
 */
/**
 * @callback AssertAnything
 * @param {unknown} [node]
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {boolean}
 */
/**
 * Check if a node passes a certain node test
 *
 * @template {Node} Y
 * @callback AssertPredicate
 * @param {unknown} [node]
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {node is Y}
 */
/**
 * Check if a node passes a test.
 * When a `parent` node is known the `index` of node should also be given.
 *
 * @type {(
 *   (<T extends Node>(node: unknown, test?: null|undefined, index?: number, parent?: Parent, context?: unknown) => node is Node) &
 *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number, parent?: Parent, context?: unknown) => node is T) &
 *   ((node?: unknown, test?: null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>, index?: number, parent?: Parent, context?: unknown) => boolean)
 * )}
 */
export var is: (<T extends import('unist').Node>(
  node: unknown,
  test?: null | undefined,
  index?: number,
  parent?: Parent,
  context?: unknown
) => node is import('unist').Node) &
  (<T_1 extends import('unist').Node>(
    node: unknown,
    test:
      | T_1['type']
      | Partial<T_1>
      | TestFunctionPredicate<T_1>
      | Array<T_1['type'] | Partial<T_1> | TestFunctionPredicate<T_1>>,
    index?: number,
    parent?: Parent,
    context?: unknown
  ) => node is T_1) &
  ((
    node?: unknown,
    test?:
      | null
      | undefined
      | Type
      | Props
      | TestFunctionAnything
      | Array<Type | Props | TestFunctionAnything>,
    index?: number,
    parent?: Parent,
    context?: unknown
  ) => boolean)
/**
 * @type {(
 *   (<T extends Node>(test?: null|undefined) => AssertPredicate<Node>) &
 *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
 *   ((test?: null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>) => AssertAnything)
 * )}
 */
export var convert: (<T extends import('unist').Node>(
  test?: null | undefined
) => AssertPredicate<Node>) &
  (<T_1 extends import('unist').Node>(
    test: T_1['type'] | Partial<T_1> | TestFunctionPredicate<T_1>
  ) => AssertPredicate<T_1>) &
  ((
    test?:
      | null
      | undefined
      | Type
      | Props
      | TestFunctionAnything
      | Array<Type | Props | TestFunctionAnything>
  ) => AssertAnything)
export type Node = import('unist').Node
export type Parent = import('unist').Parent
export type Type = string
export type Props = Record<string, unknown>
/**
 * Check if a node passes a test
 */
export type TestFunctionAnything = (
  node: Node,
  index?: number,
  parent?: Parent
) => boolean | void
/**
 * Check if a node passes a certain node test
 */
export type TestFunctionPredicate<X extends import('unist').Node> = (
  node: Node,
  index?: number,
  parent?: Parent
) => node is X
export type AssertAnything = (
  node?: unknown,
  index?: number,
  parent?: Parent
) => boolean
/**
 * Check if a node passes a certain node test
 */
export type AssertPredicate<Y extends import('unist').Node> = (
  node?: unknown,
  index?: number,
  parent?: Parent
) => node is Y